home *** CD-ROM | disk | FTP | other *** search
/ Plug-In Power Pack for Netscape Communicator / Plug-In Power Pack for Netscape Communicator.iso / plugins / dataviews / include / vupixrep.h < prev    next >
Text File  |  1997-05-08  |  25KB  |  721 lines
  1. /* 
  2.   static char SccsId[]="@(#)VUpixrep.h    V1.10    3/16/95";
  3. */
  4. /*
  5. |    file name -- VUpixrep.h
  6. |===================================================================
  7. |
  8. |                      V.I. Corporation
  9. |                       Copyright (c) 1991
  10. |
  11. |     VUpixrep.h - structures and macros for use with pixreps
  12. |
  13. |       Chris Hoffmann --- 10 Oct 1991
  14. |
  15. |===================================================================
  16. |
  17. |    Module description/function:
  18. | This module defines the pixrep structure as well as macros for
  19. | examining color components of a pixrep's pixel values. It also defines
  20. | a structure based on a pixrep called a pixscan. A pixscan contains
  21. | the necessary information to read a pixrep as a consecutive stream of
  22. | pixel values. A set of macros are provided to allow this reading to be
  23. | done easily.
  24. | 
  25. | PIXREPS
  26. | A pixrep is an abstract representation of pixel-based graphic data.
  27. | The pixels are considered to be arranged in a rectangular array,
  28. | however, there is quite a bit of flexibility in the actual layout of
  29. | the pixels in the array and in what how the actual pixel values are
  30. | interpreted. The hope is that the pixrep format is general enough to
  31. | be a superset of most raster/pixel formats we must deal with.
  32. | A set of macros are provided to make it easy to read through the
  33. | pixels in a pixrep regardless of its internal format. There are also
  34. | functions for modifying a pixrep in various ways.
  35. | 
  36. | The layout of the actual pixel data array is controlled by certain 
  37. | fields in the pixrep. What follows is a description of the allowable
  38. | variations in the layout. See the actual structure for the names of 
  39. | the fields that control each attribute.
  40. |
  41. | First the pixrep must indicate the height and width of the data in
  42. | pixels. The pixels are given as a single vector of data. The pixels 
  43. | in this vector are arranged in rows,  in left-to-right order. 
  44. | The data can be arranged so the bottom row of the picture is
  45. | first in the array (this is the VI row order) or the top row is the 
  46. | first (this is the order used by X and SunView). Each pixel in the row takes
  47. | up a certain number of bits. This number can be 1, 2, 4, 8, 16, or 32.
  48. | Generally, if the actual depth of the picture is less than the number of
  49. | bits per pixel, the data is stored in the least significant part of
  50. | those bits (for example, if the picture has depth 1 but for some
  51. | reason we were using a byte for each pixel, the low-order bit of
  52. | the byte contains the pixel value). See the description of
  53. | "direct-color" pixreps for exceptions to this. 
  54. | 
  55. | Rows can be aligned on 8, 16 or 32 bit boundaries. If on 8-bit
  56. | boundaries, rows are consecutive in memory. If on 16-bit, each row
  57. | starts on the next even address after the last byte of the previous
  58. | row. Similar is the 32-bit case, where rows start on the first address
  59. | divisible by 4 after the last unused byte.
  60. | 
  61. | If the there are fewer than 8 bits per pixel, the data is packed into
  62. | an 8, 16, or 32 bit unit. Within a unit, the pixels can be entered
  63. | into either the least-significant or the most-signficant bytes of the
  64. | unit first.  Additionally, within each byte of the unit, the pixels
  65. | can be packed in in MSB or LSB order. If the pack unit is 8, the unit
  66. | packing order is irrelevant.
  67. | 
  68. | To help make this packing order business clearer, suppose the start of
  69. | the first row in a 1-bit picture looks like the following:
  70. | 
  71. | 0011 0111 0000 1101 1100 1010 1001 1000     (spaces added for clarity)
  72. | 
  73. | Here is how this pattern would be represented in the first two bytes
  74. | of a few 1-bit deep pixreps with various formats:
  75. | 
  76. | pack-unit = 8,  pack_msf_in_byte = YES, pack_msf_in_unit = either.
  77. | 0x370D 0xCA98
  78. | pack-unit = 8,  pack_msf_in_byte = NO,  pack_msf_in_unit = either.
  79. | 0xCE0B 0x3591       (this is X's bitmap format)
  80. | pack-unit = 16, pack_msf_in_byte = YES, pack_msf_in_unit = YES.
  81. | 0x370D 0xCA98       (this is SunView 680x0 bitmap format)
  82. | pack-unit = 16, pack_msf_in_byte = YES, pack_msf_in_unit = NO.
  83. | 0x0D37 0x98CA    
  84. | pack-unit = 16, pack_msf_in_byte = NO,  pack_msf_in_unit = NO.
  85. | 0xB0EC 0x1953       (this is SunView I386 bitmap format)
  86. | pack-unit = 16, pack_msf_in_byte = NO,  pack_msf_in_unit = YES.
  87. | 0xECB0 0x5319       
  88. | pack-unit = 32, pack_msf_in_byte = YES, pack_msf_in_unit = YES.
  89. | 0x370D 0xCA98
  90. | pack-unit = 8,  pack_msf_in_byte = NO,  pack_msf_in_unit = NO.
  91. | 0x1953 0xBEOC
  92. |
  93. | A row is always an integral multiple of the pack unit long. When
  94. | determining the number of bytes per row, first figure the size by
  95. | finding the number of pack units required, then add additional bytes
  96. | as necessary to satisfy the row alignment.
  97. |
  98. | Unused bits between
  99. | the end of one row and the start of the next may have any value. If
  100. | there are more than 8 bits per pixel, the byte order in each pixel is
  101. | the native order.
  102. | 
  103. | There are two possible formats for the pixel values: they may be
  104. | either "indirect-color" or "direct-color". Indirect-color pixel values
  105. | are indices into a color table; direct-color store actual
  106. | red/green/blue component values.
  107. | 
  108. | If a pixrep points to a color table, the pixel values must be
  109. | indirect-color. Since a color table has at most 256 entries, the depth
  110. | of the pixrep can't be greater than 8. A pixrep can optionally contain
  111. | a pointer to a boolean vector (of length 256) indicating which colors
  112. | in the color table are actually used by the pixrep. Knowing this can
  113. | potentially speed up some pixrep operations, particularly converting
  114. | pixreps to rasters.
  115. | 
  116. | If the color table pointer field is NULL, the pixrep must be
  117. | direct-color. In this case there are three masks indicating where each
  118. | component color is stored in a pixel. Components may be located
  119. | anywhere in the pixel, but each component must occupy consecutive
  120. | bits.  For example, in a typical 24-bit color system each pixel is
  121. | 32-bits long, where the most-significant byte is unused, the next byte
  122. | contains red intensity, the third byte the green and the last byte the
  123. | blue. This layout would be indicated by having a red mask of
  124. | 0x00FF0000, a green mask of 0x00FF00, and a blue mask of 0x000000FF.
  125. | For efficiency's sake, a pixrep also stores where the right-most "1"
  126. | bit of each mask is located.
  127. | 
  128. | PIXSCANS
  129. | Pixscans are an easy way to access pixels in a pixrep. Using a
  130. | pixscan, pixels from a pixrep can be read and written, in either row or
  131. | column order, as a continuous stream of pixels. The current location
  132. | in the pixrep can be changed at any time. A pixrep can be shared by
  133. | any number of pixscans all reading and writing to different portions
  134. | of the pixrep.
  135. |
  136. |    
  137. |    
  138. | ------------------------------------------------------------------
  139. |   Module contents:
  140. |   Macro Name               Description
  141. |   -------------       -------------------------------
  142. |   GETREDPXRP        Get the red component from a direct-color pixel value
  143. |   GETGRNPXRP        "   "   green       "
  144. |   GETBLUPXRP        "   "   blue        "
  145. |   PUTREDPXRP        Put the red component into a direct-color pixel value
  146. |   PUTGRNPXRP        "   "   green       "
  147. |   PUTBLUPXRP        "   "   blue        "
  148. |   PIXPXRP        Create a pixel value from all three components
  149. |   PIXSCALE        Scale component to different range
  150. |   GETREDSTD         Get the red component from a VI standard 24-bit pixel
  151. |   GETGRNSTD         "   "   green       "
  152. |   GETBLUSTD         "   "   blue        "
  153. |   PUTREDSTD         Put the red component into a VI standard 24-bit pixel
  154. |   PUTGRNSTD         "   "   green       "
  155. |   PUTBLUSTD         "   "   blue        "
  156. |   PIXSTD         Create a standard pixel value from all three components
  157. |   ISPIXSTD        Is the pixel value in standard VI format?
  158. |
  159. |   PXSCANPOINT        Make a given pixel the next pixel to be read
  160. |   PXSCANREAD        Read the current pixel and advance pixscan pointer
  161. |   PXSCANWRITE        Write to the current pixel and advance pointer
  162. |   PXSCANREADL        Read in left-to-right, bottom-to-top order
  163. |   PXSCANREADR        Read in right-to-left, top-to-bottom order
  164. |   PXSCANREADD        Read in top-to-bottom, left-to-right order
  165. |   PXSCANREADU        Read in bottom-to-top, left-to-right order
  166. |   PXSCANWRITER        Write in left-to-right, bottom-to-top order
  167. |   PXSCANWRITER        Write in right-to-left, top-to-bottom order
  168. |   PXSCANWRITED        Write in top-to-bottom, left-to-right order
  169. |   PXSCANWRITEU        Write in bottom-to-top, left-to-right order
  170. |   
  171. |====================================================================
  172. */
  173. #ifndef VIPXRP
  174. #define VIPXRP
  175. #include "std.h"
  176. #include "dvstd.h"
  177.  
  178. /*  Module Include Files:  */
  179.  
  180. #include "std.h"
  181. #include "dvstd.h"
  182. #include "dverrors.h"
  183.  
  184.  
  185.  
  186. /*  Module Structure Definitions:  */
  187.  
  188. /* the actual pixrep structure typedef is in the file dvstd.h */
  189.  
  190. #if 0        
  191.         
  192. typedef struct
  193.   {
  194.   int width, height;        /* width and height in pixels */
  195.   UBYTE depth;            /* number of bits of color information */
  196.   UBYTE bits_per_pixel;        /* 1,2,4,8,16,32 bits */
  197.   UBYTE row_alignment;        /* 8,16,32==Rows aligned on char,short,LONG */
  198.   DV_BOOL  origin_at_ll;        /* is origin in lower-left? */
  199.   UBYTE pack_unit;        /* if bits/pixel < 8, packing unit */
  200.   DV_BOOL  pack_msf_in_byte;    /* if bits/pixel < 8, order of pixels in byte */
  201.   DV_BOOL  pack_msf_in_unit;    /* if bits/pixel < 8, order of bytes in unit */
  202.   LONG   pixels_length;        /* length of pixel array */
  203.   UBYTE *pixels;        /* actual pixels */
  204.   /* if (pclut != NULL), pixels are index into color table (*pclut) */
  205.   COLOR_TABLE *pclut;
  206.   DV_BOOL *color_used;        /* which colors actually used (if known) */
  207.   /* if (pclut == NULL), pixels are direct color: */
  208.   ULONG red_mask;        
  209.   int   red_shift;        
  210.   ULONG grn_mask;        /* For green component of pixel, calculate */
  211.   int   grn_shift;        /* ((pixel & grn_mask) >> grn_shift)       */
  212.   ULONG blu_mask;        
  213.   int   blu_shift;        /* & similarly for red and blue components */
  214.   } PIXREP;
  215.  
  216. #endif 
  217.  
  218. /* enum for function VUpxFlip() */
  219. typedef enum
  220.   {
  221.   V_PX_HORIZONTAL,        /* flip over horizontal axis */
  222.   V_PX_VERTICAL            /* flip over vertical axis */
  223.   } V_PX_FLIP_ENUM;
  224.  
  225. /* enum for function VUpxMerge() */
  226. typedef enum
  227.   {
  228.   V_PX_COPY,            /* copy source to target */
  229.   V_PX_AND,            /* and source and target */
  230.   V_PX_OR,            /* or source and target */
  231.   V_PX_XOR            /* xor source and target */
  232.   } V_PX_MERGEMODE_ENUM;
  233.  
  234. /*------------------------ pixrep pixel macros ---------------------------- */
  235. /*
  236.  | Macros for getting color information from direct-color pixreps.
  237.  | In all cases, the colors are in the scale of the pixrep. That is,
  238.  | if the red component is 3 bits wide, then the component values
  239.  | must be in the range 0..7.
  240.  |
  241.  |   Arguments:
  242.  |    pix            -- a pixel value read from a pixrep
  243.  |    pr            -- the pixrep that the pixel was read from
  244.  */
  245. #define GETREDPXRP( pix, pr )  (((pix) & (pr).red_mask) >> (pr).red_shift)
  246. #define GETGRNPXRP( pix, pr )  (((pix) & (pr).grn_mask) >> (pr).grn_shift)
  247. #define GETBLUPXRP( pix, pr )  (((pix) & (pr).blu_mask) >> (pr).blu_shift)
  248.  
  249. #define PUTREDPXRP( pix, r, pr ) ( ( (pix) & ~(pr).red_mask ) | \
  250.                    ( ((r) << (pr).red_shift) & (pr).red_mask) )
  251. #define PUTGRNPXRP( pix, g, pr ) ( ( (pix) & ~(pr).grn_mask ) | \
  252.                    ( ((g) << (pr).grn_shift) & (pr).grn_mask) )
  253. #define PUTBLUPXRP( pix, b, pr ) ( ( (pix) & ~(pr).blu_mask ) | \
  254.                    ( ((b) << (pr).blu_shift) & (pr).blu_mask) )
  255.  
  256. /*
  257.  | Macro to build a pixrep pixel value from the three color components.
  258.  | Again, the red, green, blue components must be already scaled
  259.  |   Arguments:
  260.  |    r, g, b            -- color components to use when creating pixel
  261.  |    pr            -- the pixrep defining the pixel format
  262.  */
  263. #define PIXPXRP( r, g, b, pr ) ((((r) << (pr).red_shift) & (pr).red_mask) | \
  264.                   (((g) << (pr).grn_shift) & (pr).grn_mask) | \
  265.                   (((b) << (pr).blu_shift) & (pr).blu_mask) )
  266.  
  267. #define PIXSCALE( p, bs, bt ) (((bs)==(bt)) ? \
  268.                          (p) : \
  269.                          ((bs)>(bt)) ? \
  270.                                ((p)>>((bs)-(bt))) : \
  271.                                (((p)<<((bt)-(bs))) + \
  272.                                      ((1<<((bt)-((bs)+1)))-1) \
  273.                         ) \
  274.                    )
  275.  
  276. /* macros for performing the equivalent actions on a pixel in "standard" 
  277. |  24-bit RGB format.
  278. */
  279. #define GETREDSTD( p )  ( ((p) & 0xFF0000) >> 16)
  280. #define GETGRNSTD( p )  ( ((p) & 0x00FF00) >>  8)
  281. #define GETBLUSTD( p )  ( ((p) & 0x0000FF)      )
  282. #define PUTREDSTD( p, r ) ( ((p) & 0x00FFFF) | (((r) << 16) & 0xFF0000) )
  283. #define PUTGRNSTD( p, g ) ( ((p) & 0xFF00FF) | (((g) <<  8) & 0x00FF00) )
  284. #define PUTBLUSTD( p, b ) ( ((p) & 0xFFFF00) | (((r)      ) & 0x0000FF) )
  285. #define PIXSTD( r, g, b ) ( (((r) << 16) & 0xFF0000) | \
  286.                 (((g) <<  8) & 0x00FF00) | \
  287.                 (((r)      ) & 0x0000FF) | \
  288.                 0x1000000 )
  289. /* determines whether a pixel value is in standard format */
  290. #define ISPIXSTD( p ) ( (p) & 0x1000000 )
  291.  
  292. /*------------------------ pixscan macros ---------------------------- */
  293. /*
  294. |    These macros are used to efficiently read pixels, in order, from
  295. |    a pixrep. To do this two "private" structures are needed: a
  296. |    "pixscan" and a "pixptr". 
  297. |
  298. |       The following types hold for all the macros:
  299. |    pxrp       is a PIXREP. Not a pointer to a PIXREP, but a PIXREP.
  300. |            If all you have is a PIXREP ptr, dereference it
  301. |            with "*".
  302. |
  303. |    pxscan        is a PIXSCAN. Not a pointer to a PIXSCAN.
  304. |
  305. |    pixptr        is a PIXPTR. You may want to declare this
  306. |            a register variable.
  307. |
  308. |    source_pixel, target_pixel    are ULONG
  309. |
  310. |    Macros:
  311. |       -------
  312. |    PXSCANPOINT(pxrp, pxscan, pixptr, x, y) 
  313. |    PXSCANREAD(target_pixel, pxrp, pxscan, pixptr ) 
  314. |    PXSCANWRITE( pxrp, pxscan, pixptr, source_pixel ) 
  315. |    PXSCANREADL(target_pixel, pxrp, pxscan, pixptr ) 
  316. |    PXSCANREADR(target_pixel, pxrp, pxscan, pixptr ) 
  317. |    PXSCANREADD(target_pixel, pxrp, pxscan, pixptr ) 
  318. |    PXSCANREADU(target_pixel, pxrp, pxscan, pixptr ) 
  319. |    PXSCANWRITEL( pxrp, pxscan, pixptr, source_pixel ) 
  320. |    PXSCANWRITER( pxrp, pxscan, pixptr, source_pixel ) 
  321. |    PXSCANWRITED( pxrp, pxscan, pixptr, source_pixel ) 
  322. |    PXSCANWRITEU( pxrp, pxscan, pixptr, source_pixel ) 
  323. |
  324. |    To initialize a pixscan, call VUpxScanInit.
  325. |    The pixscan is pointing at pixel (0,0). That is, that is the 
  326. |    first pixel that will be read. Rows can be numbered either
  327. |    in with origin at lower-left (row 0 is bottom row) or upper-right
  328. |       (row 0 is top row).
  329. |
  330. |    To point the pixscan at some other pixel, use PXSCANPOINT.
  331. |    Remember that the order the rows are numbered depends on
  332. |    what row-order you specified when you created the pixscan.
  333. |
  334. |    Read a pixel with PXSCANREAD. The value of the current pixel
  335. |    is put in target_pixel and the pixscan is set to point to the next 
  336. |    pixel to the right. At the end of a row, the pixscan is set to point at
  337. |    the left-most pixel of the next-higher-numbered row (upwards if
  338. |       origin in lower-left, downwards otherwise).
  339. |
  340. |    Write a pixel value with PXSCANWRITE. source_pixel is written at the
  341. |    current point in the pixscan and the pointer is adjusted as
  342. |    in PXSCANREAD. 
  343. |
  344. |    PXSCANREADL reads the pixscan in left to right, increasing row
  345. |        order (the same order as PXSCANREAD).
  346. |    PXSCANREADR reads the pixscan right to left, increasing row order
  347. |    PXSCANREADU reads the pixscan decreasing row, left to right col
  348. |        order ("DOWN" a column instead of ACROSS a row)
  349. |    PXSCANREADD reads the pixscan increasing row, left to right col
  350. |        order ("UP" a column instead of ACROSS a row)
  351. |
  352. |    Similarly for PXSCANWRITE{L,R,U,D}
  353. |
  354. |
  355. */
  356.  
  357. #define PXSCANREADL(target_pixel, pxrp, pxscan, pixptr ) PXSCANREAD(target_pixel, pxrp, pxscan, pixptr )
  358. #define PXSCANREAD(target_pixel, pxrp, pxscan, pixptr ) \
  359. do \
  360. { \
  361.   if ((pxscan).iCol == (pxrp).width) \
  362.     { \
  363.     PXSCANROWS(pxrp, pxscan, pixptr) \
  364.     } \
  365.   switch ((pxrp).bits_per_pixel) \
  366.     { \
  367.   case 32: \
  368.     (target_pixel) = *(pixptr).pul++; \
  369.     break; \
  370.   case 16: \
  371.     (target_pixel) = (unsigned short)*((pixptr).pus++); \
  372.     break; \
  373.   case 8: \
  374.     (target_pixel) = (UBYTE)*((pixptr).pub++); \
  375.     break; \
  376.   default: \
  377.     (target_pixel) = (*(pixptr).pub >> (pxscan).shift_array[(pxscan).bit_offset]) & (pxscan).read_mask; \
  378.     PXSCANBITI( pxrp, pxscan, pixptr ) \
  379.     } \
  380.   (pxscan).iCol += 1; \
  381. } \
  382. while(0)
  383.  
  384. #define  PXSCANWRITEL( pxrp, pxscan, pixptr, source_pixel ) PXSCANWRITE( pxrp, pxscan, pixptr, source_pixel )
  385. #define  PXSCANWRITE( pxrp, pxscan, pixptr, source_pixel ) \
  386. do \
  387. { \
  388.   if ((pxscan).iCol == (pxrp).width) \
  389.     { \
  390.     PXSCANROWS(pxrp, pxscan, pixptr) \
  391.     } \
  392.   switch ((pxrp).bits_per_pixel) \
  393.     { \
  394.   case 32: \
  395.     *(pixptr).pul++ = source_pixel; \
  396.     break; \
  397.   case 16: \
  398.     *(pixptr).pus++ = (unsigned short)source_pixel; \
  399.     break; \
  400.   case 8: \
  401.     *(pixptr).pub++ = (UBYTE)source_pixel; \
  402.     break; \
  403.   default: \
  404.     *(pixptr).pub &= ~(pxscan).mask_array[(pxscan).bit_offset] ; \
  405.     *(pixptr).pub |= ((UBYTE)source_pixel << (pxscan).shift_array[(pxscan).bit_offset]) ; \
  406.     PXSCANBITI( pxrp, pxscan, pixptr ) \
  407.     break; \
  408.     } \
  409.     (pxscan).iCol += 1; \
  410. } \
  411. while(0)
  412.  
  413. #define PXSCANREADR(target_pixel, pxrp, pxscan, pixptr ) \
  414. do \
  415. { \
  416.   if ((pxscan).iCol < 0) \
  417.     { \
  418.     (pxscan).iCol = (pxrp).width-1; \
  419.     (pxscan).iRow += 1; \
  420.     PXSCANPOINT( pxrp, pxscan, pixptr, (pxscan).iCol, (pxscan).iRow ); \
  421.     } \
  422.   switch ((pxrp).bits_per_pixel) \
  423.     { \
  424.   case 32: \
  425.     (target_pixel) = *(pixptr).pul--; \
  426.     break; \
  427.   case 16: \
  428.     (target_pixel) = (unsigned short)*((pixptr).pus--); \
  429.     break; \
  430.   case 8: \
  431.     (target_pixel) = (UBYTE)*((pixptr).pub--); \
  432.     break; \
  433.   default: \
  434.     (target_pixel) = (*(pixptr).pub >> (pxscan).shift_array[(pxscan).bit_offset]) & (pxscan).read_mask; \
  435.      PXSCANBITD( pxrp, pxscan, pixptr ) \
  436.     } \
  437.   (pxscan).iCol -= 1; \
  438. } \
  439. while(0)
  440.  
  441. #define  PXSCANWRITER( pxrp, pxscan, pixptr, source_pixel ) \
  442. do \
  443. { \
  444.   if ((pxscan).iCol < 0) \
  445.     { \
  446.     (pxscan).iCol = (pxrp).width-1; \
  447.     (pxscan).iRow += 1; \
  448.     PXSCANPOINT( pxrp, pxscan, pixptr, (pxscan).iCol, (pxscan).iRow ); \
  449.     } \
  450.   switch ((pxrp).bits_per_pixel) \
  451.     { \
  452.   case 32: \
  453.     *(pixptr).pul-- = source_pixel; \
  454.     break; \
  455.   case 16: \
  456.     *(pixptr).pus-- = (unsigned short)source_pixel; \
  457.     break; \
  458.   case 8: \
  459.     *(pixptr).pub-- = (UBYTE)source_pixel; \
  460.     break; \
  461.   default: \
  462.     *(pixptr).pub &= ~(pxscan).mask_array[(pxscan).bit_offset] ; \
  463.     *(pixptr).pub |= ((UBYTE)source_pixel << (pxscan).shift_array[(pxscan).bit_offset]) ; \
  464.     PXSCANBITD( pxrp, pxscan, pixptr ) \
  465.     } \
  466.     (pxscan).iCol -= 1; \
  467. } \
  468. while(0)
  469.  
  470. #define PXSCANREADD(target_pixel, pxrp, pxscan, pixptr ) \
  471. do \
  472. { \
  473.   if ((pxscan).iRow < 0) \
  474.     { \
  475.     (pxscan).iRow  = (pxrp).height-1; \
  476.     PXSCANCOLI( pxrp, pxscan, pixptr ) \
  477.     } \
  478.   PXSCANRD(target_pixel, pxrp, pxscan, pixptr ) \
  479.   (pxscan).iRow -= 1; \
  480.   if ((pxscan).rows_increase) \
  481.     (pixptr).pub -= (pxscan).bytes_per_row; \
  482.   else \
  483.     (pixptr).pub += (pxscan).bytes_per_row; \
  484. } \
  485. while(0)
  486.  
  487. #define PXSCANWRITED(pxrp, pxscan, pixptr, source_pixel ) \
  488. do \
  489. { \
  490.   if ((pxscan).iRow < 0) \
  491.     { \
  492.     (pxscan).iRow  = (pxrp).height-1; \
  493.     PXSCANCOLI( pxrp, pxscan, pixptr ) \
  494.     } \
  495.   PXSCANWR(pxrp, pxscan, pixptr, source_pixel ) \
  496.     (pxscan).iRow -= 1; \
  497.   if ((pxscan).rows_increase) \
  498.     (pixptr).pub -= (pxscan).bytes_per_row; \
  499.   else \
  500.     (pixptr).pub += (pxscan).bytes_per_row; \
  501. } \
  502. while(0)
  503.  
  504. #define PXSCANREADU(target_pixel, pxrp, pxscan, pixptr ) \
  505. do \
  506. { \
  507.   if ((pxscan).iRow >= (pxrp).height) \
  508.     { \
  509.     (pxscan).iRow  = 0; \
  510.     PXSCANCOLI( pxrp, pxscan, pixptr ) \
  511.     } \
  512.   PXSCANRD(target_pixel, pxrp, pxscan, pixptr ) \
  513.   (pxscan).iRow += 1; \
  514.   if ((pxscan).rows_increase) \
  515.     (pixptr).pub += (pxscan).bytes_per_row; \
  516.   else \
  517.     (pixptr).pub -= (pxscan).bytes_per_row; \
  518. } \
  519. while(0)
  520.  
  521. #define PXSCANWRITEU(pxrp, pxscan, pixptr, source_pixel ) \
  522. do \
  523. { \
  524.   if ((pxscan).iRow >= (pxrp).height) \
  525.     { \
  526.     (pxscan).iRow  = 0; \
  527.     PXSCANCOLI( pxrp, pxscan, pixptr ) \
  528.     } \
  529.   PXSCANWR(pxrp, pxscan, pixptr, source_pixel ) \
  530.   (pxscan).iRow += 1; \
  531.   if ((pxscan).rows_increase) \
  532.     (pixptr).pub += (pxscan).bytes_per_row; \
  533.   else \
  534.     (pixptr).pub -= (pxscan).bytes_per_row; \
  535. } \
  536. while(0)
  537.  
  538. #define PXSCANPOINT(pxrp, pxscan, pixptr, x, y)  \
  539. do \
  540.   {  \
  541.   UBYTE *qxy_prow;  \
  542.   int qxy_ppb;  \
  543.     \
  544.   if ((pxscan).rows_increase)  \
  545.     qxy_prow = (pxrp).pixels + ((pxscan).bytes_per_row * (y));  \
  546.   else  \
  547.     qxy_prow = (pxrp).pixels +  \
  548.       ((pxscan).bytes_per_row * ((pxrp).height - ((y)+1)));  \
  549.   switch ((pxrp).bits_per_pixel)  \
  550.     {  \
  551.   case 32:  \
  552.     (pixptr).pul = ((ULONG*)qxy_prow + (x));  \
  553.     break;  \
  554.   case 16:  \
  555.     (pixptr).pus = ((unsigned short*)qxy_prow + (x));  \
  556.     break;  \
  557.   case 8:  \
  558.     (pixptr).pub = (UBYTE*)qxy_prow + (x);  \
  559.     break;  \
  560.   default:  \
  561.     qxy_ppb =  (x) * (pxrp).bits_per_pixel;  \
  562.     qxy_prow += ((pxrp).pack_unit/8) * (qxy_ppb / (pxrp).pack_unit); \
  563.     qxy_ppb %= (pxrp).pack_unit; \
  564.     (pxscan).unit_offset = qxy_ppb / 8; \
  565.     (pxscan).bit_offset = qxy_ppb % 8; \
  566.     if ((pxscan).always_increasing) \
  567.       (pixptr).pub = qxy_prow + (pxscan).unit_offset; \
  568.     else \
  569.       (pixptr).pub = qxy_prow + (pxscan).max_unit_offset - (pxscan).unit_offset; \
  570.     break;  \
  571.     }  \
  572.   (pxscan).iCol = x;  \
  573.   (pxscan).iRow = y;  \
  574.   (pxscan).colstart = (pixptr).pub;  \
  575.   } \
  576. while(0)  
  577.  
  578. /**************************************************************************/
  579. /**************************************************************************/
  580. /********************** VI internal definitions ***************************/
  581. /**************************************************************************/
  582. /**************************************************************************/
  583.  
  584. #define PXSCANBITI( pxrp, pxscan, pixptr )  \
  585. {  \
  586.   (pxscan).bit_offset += (pxrp).bits_per_pixel;  \
  587.   if ((pxscan).bit_offset > 7) \
  588.     { \
  589.     (pxscan).bit_offset = 0; \
  590.     if ((pxscan).always_increasing) \
  591.       ++(pixptr).pub; \
  592.     else \
  593.       if ((pxscan).unit_offset++ < (pxscan).max_unit_offset) \
  594.     --(pixptr).pub; \
  595.       else \
  596.     { \
  597.     (pxscan).unit_offset = 0; \
  598.     (pixptr).pub += (pxscan).unit_step; \
  599.     } \
  600.       } \
  601. } 
  602.  
  603. #define PXSCANBITD( pxrp, pxscan, pixptr )  \
  604. {  \
  605.   (pxscan).bit_offset -= (pxrp).bits_per_pixel;  \
  606.   if ((pxscan).bit_offset < 0) \
  607.     { \
  608.     (pxscan).bit_offset = (pxscan).max_bit_offset; \
  609.     if ((pxscan).always_increasing) \
  610.       --(pixptr).pub; \
  611.     else \
  612.       if ((pxscan).unit_offset-- < 0) \
  613.     ++(pixptr).pub; \
  614.       else \
  615.     { \
  616.     (pxscan).unit_offset = (pxscan).max_bit_offset; \
  617.     (pixptr).pub -= (pxscan).unit_step; \
  618.     } \
  619.       } \
  620. }
  621.  
  622. #define PXSCANWR(pxrp, pxscan, pixptr, source_pixel) \
  623.   switch ((pxrp).bits_per_pixel) \
  624.     { \
  625.   case 32: \
  626.     *(pixptr).pul = source_pixel; \
  627.     break; \
  628.   case 16: \
  629.     *(pixptr).pus = (unsigned short)source_pixel; \
  630.     break; \
  631.   case 8: \
  632.     *(pixptr).pub = (UBYTE)source_pixel; \
  633.     break; \
  634.   default: \
  635.     *(pixptr).pub &= ~(pxscan).mask_array[(pxscan).bit_offset] ; \
  636.     *(pixptr).pub |= ((UBYTE)source_pixel << (pxscan).shift_array[(pxscan).bit_offset]) ; \
  637.     break; \
  638.     } 
  639.  
  640. #define PXSCANRD(target_pixel, pxrp, pxscan, pixptr) \
  641.   switch ((pxrp).bits_per_pixel) \
  642.     { \
  643.   case 32: \
  644.     (target_pixel) = *(pixptr).pul; \
  645.     break; \
  646.   case 16: \
  647.     (target_pixel) = (unsigned short)*(pixptr).pus; \
  648.     break; \
  649.   case 8: \
  650.     (target_pixel) = (UBYTE)*(pixptr).pub; \
  651.     break; \
  652.   default: \
  653.     (target_pixel) = (*(pixptr).pub >> (pxscan).shift_array[(pxscan).bit_offset]) & (pxscan).read_mask; \
  654.     break; \
  655.     } 
  656.  
  657. #define PXSCANCOLI(pxrp, pxscan, pixptr) \
  658.   (pxscan).iCol += 1; \
  659.   (pixptr).pub = (pxscan).colstart; \
  660.   switch ((pxrp).bits_per_pixel) \
  661.     { \
  662.   case 32: \
  663.     ++(pixptr).pul; \
  664.     break; \
  665.   case 16: \
  666.     ++(pixptr).pus; \
  667.     break; \
  668.   case 8: \
  669.     ++(pixptr).pub; \
  670.     break; \
  671.   default: \
  672.     PXSCANBITI(pxrp, pxscan, pixptr) \
  673.     break; \
  674.     } \
  675.   (pxscan).colstart = (pixptr).pub;
  676.  
  677. #define PXSCANROWS(pxrp, pxscan, pixptr) \
  678.     (pxscan).iCol = 0;  \
  679.     (pxscan).iRow += 1;  \
  680.     (pxscan).bit_offset = 0;  \
  681.     (pxscan).unit_offset = 0;  \
  682.     if ((pxscan).rows_increase) \
  683.       (pixptr).pub = (pxrp).pixels + (pxscan).iRow *  \
  684.     (pxscan).bytes_per_row;  \
  685.     else  \
  686.       (pixptr).pub = (pxrp).pixels +  \
  687.     ((pxrp).height - ((pxscan).iRow+1)) * (pxscan).bytes_per_row;  \
  688.     (pixptr).pub += (pxscan).max_unit_offset; 
  689.  
  690.  
  691. /* "private" structures */
  692.  
  693. typedef struct
  694.   {
  695.   UBYTE mask_array[8];
  696.   UBYTE shift_array[8];
  697.   UBYTE read_mask;
  698.   int iCol, iRow;
  699.   int bytes_per_row;
  700.   int bit_offset;
  701.   int max_bit_offset;
  702.   int unit_offset;
  703.   int max_unit_offset;
  704.   int unit_step;
  705.   DV_BOOL always_increasing;
  706.   DV_BOOL rows_increase;
  707.   UBYTE *colstart;
  708.   } PIXSCAN;
  709.  
  710. typedef union
  711.   {
  712.   UBYTE  *pub;
  713.   unsigned short *pus;
  714.   ULONG  *pul;
  715.   } PIXPTR;
  716.  
  717.  
  718.  
  719.  
  720. #endif /* VIPXRP */
  721.